import 'package:intl/intl.dart';
import 'package:xindong/common/xindong_methods.dart';

class XinDongDateFormat {
  static const formatYMDHMS = 'yyyy-MM-dd HH:mm:ss';
  static const formatYMDHM = 'yyyy-MM-dd HH:mm';
  static const formatYMD = 'yyyy-MM-dd';
  static const formatMDHM = 'MM-dd HH:mm';
  static const formatHMS = 'HH:mm:ss';
}

class XinDongCalendarUtil {
  // 是不是昨天
  //
  // dateTime 日期对象
  static bool isYesterday(DateTime dateTime) {
    DateTime nowDate = DateTime.now();
    // 比较相差的天数（去除时分秒来计算间隔的日期天数，否则计算的是相差的时间）
    DateTime newNowDate = DateTime(nowDate.year, nowDate.month, nowDate.day);
    DateTime newTimeDate = DateTime(dateTime.year, dateTime.month, dateTime.day);
    int inDays = newNowDate.difference(newTimeDate).inDays;
    return inDays == 1;
  }

  // 是不是今天
  //
  // dateTime 日期对象
  static bool isToday(DateTime dateTime) {
    DateTime nowDate = DateTime.now();
    // 比较相差的天数（去除时分秒来计算间隔的日期天数，否则计算的是相差的时间）
    DateTime newNowDate = DateTime(nowDate.year, nowDate.month, nowDate.day);
    DateTime newTimeDate = DateTime(dateTime.year, dateTime.month, dateTime.day);
    return newNowDate.isAtSameMomentAs(newTimeDate);
  }

  // 是不是前天
  //
  // dateTime 日期对象
  static bool isTheDayBeforeYesterday(DateTime dateTime) {
    DateTime nowDate = DateTime.now();
    // 比较相差的天数（去除时分秒来计算间隔的日期天数，否则计算的是相差的时间）
    DateTime newNowDate = DateTime(nowDate.year, nowDate.month, nowDate.day);
    DateTime newTimeDate = DateTime(dateTime.year, dateTime.month, dateTime.day);
    int inDays = newNowDate.difference(newTimeDate).inDays;
    return inDays == 2;
  }

  // 是不是同一天
  //
  // dateTime 日期对象
  static bool isSameDay(DateTime oneDateTime, DateTime secondDateTime) {
    // 比较相差的天数（去除时分秒来计算间隔的日期天数，否则计算的是相差的时间）
    DateTime newOneDateTime = DateTime(oneDateTime.year, oneDateTime.month, oneDateTime.day);
    DateTime newSecondDateTime = DateTime(secondDateTime.year, secondDateTime.month, secondDateTime.day);
    return newOneDateTime.isAtSameMomentAs(newSecondDateTime);
  }

  // 时间戳转日期字符串
  //
  // timestamp 时间戳毫秒13位
  // format 格式化样式
  static String dateFormat(int timestamp, {String format = XinDongDateFormat.formatYMDHMS}) {
    return dateFormatDateTime(DateTime.fromMillisecondsSinceEpoch(timestamp), format: format);
  }

  // 日期对象转日期字符串
  //
  // dateTime 日期对象
  // format 格式化样式
  static String dateFormatDateTime(DateTime dateTime, {String format = XinDongDateFormat.formatYMDHMS}) {
    return DateFormat(format).format(dateTime);
  }

  // 字符串转日期对象
  //
  // dateText 时间字符串2021-12-31
  static DateTime? dateTimeFromString(String dateText, {String format = XinDongDateFormat.formatYMD}) {
    DateFormat dateFormat = DateFormat(format);
    return dateFormat.parse(dateText, false);
  }

  // 多少年前的日期对象
  static DateTime yearsAgo(int years) {
    var nowDate = DateTime.now();
    return DateTime(nowDate.year - years, nowDate.month, nowDate.day);
  }

  // 多少天前的日期对象
  static DateTime daysAgo({DateTime? dateTime, int days = 0}) {
    var nowDate = dateTime ?? DateTime.now();
    return nowDate.add(Duration(days: -days));
  }

  // 时间文本
  // 今天23:59 12-31 23:59 2021-12-31 23:59
  //
  // timestamp 时间戳毫秒13位
  // serverSeconds 服务器时间（秒）
  static String timeText(int timestamp, {int? serverSeconds}) {
    String time = '';
    DateTime now = DateTime.fromMillisecondsSinceEpoch((serverSeconds ?? 0) * 1000);
    DateTime timeDate = DateTime.fromMillisecondsSinceEpoch(timestamp);
    if (now.year == timeDate.year) {
      if (now.day == timeDate.day && now.month == timeDate.month) {
        time = "今天 ${timeDate.hour.toString().padLeft(2, '0')}:${timeDate.minute.toString().padLeft(2, '0')}";
      } else {
        time =
            "${timeDate.month.toString().padLeft(2, '0')}-${timeDate.day.toString().padLeft(2, '0')} ${timeDate.hour.toString().padLeft(2, '0')}:${timeDate.minute.toString().padLeft(2, '0')}";
      }
    } else {
      time = dateFormat(timestamp, format: XinDongDateFormat.formatYMDHM);
    }
    return time;
  }

  // 秒转换成 HH:mm:ss/mm:ss
  //
  // seconds 秒
  // maxSeconds 最大秒数，超过则显示--:--，为0则不限制
  static String timeTextHMS(int seconds, {int maxSeconds = 0}) {
    try {
      if (maxSeconds != 0 && maxSeconds < seconds) {
        return "--:--";
      }
      Duration duration = Duration(seconds: seconds);
      List<String> parts = duration.toString().split(':');
      if (parts.length < 2) {
        return "";
      } else if (parts[0] == "0" || parts[0] == "00") {
        //mm:ss
        return "${parts[1]}:${parts[2].substring(0, 2)}";
      } else {
        //HH:mm:ss
        return "${parts[0]}:${parts[1]}:${parts[2].substring(0, 2)}";
      }
    } catch (e) {
      mCatchPrint(e);
      return "--:--";
    }
  }

  // 发布时间显示
  // 是今天的
  //   大于1小时显示n小时前
  //   大于5分钟 - n分钟前
  //   5分钟以内 - 刚刚
  // 1天 - 昨天+时:分
  // 2天 - 前天+时:分
  // 大于等于3天 - 月-日+时:分
  // 大于1年的 - 年-月-日+时:分
  //
  // milliseconds 毫秒
  // serverSeconds 服务器时间（秒）
  //
  // dateTime1.difference(dateTime2).inDays，dateTime1-dateTime2
  static String publicTime(int? milliseconds, {int? serverSeconds}) {
    if (milliseconds == null) {
      return "";
    }
    DateTime nowDate = DateTime.fromMillisecondsSinceEpoch(
        serverSeconds != null ? serverSeconds * 1000 : DateTime.now().millisecondsSinceEpoch);
    DateTime timeDate = DateTime.fromMillisecondsSinceEpoch(milliseconds);
    if (nowDate.year == timeDate.year) {
      // 今天
      if (nowDate.day == timeDate.day && nowDate.month == timeDate.month) {
        // 比较相差的秒数
        int inSeconds = ((nowDate.millisecondsSinceEpoch - milliseconds) / 1000).round();
        if (inSeconds >= 60 * 60) {
          return "${(inSeconds / 60 / 60).round()}小时前";
        }
        if (inSeconds > 5 * 60) {
          return "${(inSeconds / 60).round()}分钟前";
        }
        return "刚刚";
      } else {
        // 比较相差的天数（去除时分秒来计算间隔天数）
        DateTime newNowDate = DateTime(nowDate.year, nowDate.month, nowDate.day);
        DateTime newTimeDate = DateTime(timeDate.year, timeDate.month, timeDate.day);
        int inDays = newNowDate.difference(newTimeDate).inDays;
        // 判断昨天
        if (inDays == 1) {
          return "昨天 ${timeDate.hour.toString().padLeft(2, '0')}:${timeDate.minute.toString().padLeft(2, '0')}";
        }
        // 判断前天
        if (inDays == 2) {
          return "前天 ${timeDate.hour.toString().padLeft(2, '0')}:${timeDate.minute.toString().padLeft(2, '0')}";
        }
        return "${timeDate.month.toString().padLeft(2, '0')}-${timeDate.day.toString().padLeft(2, '0')}";
      }
    } else {}
    return dateFormat(milliseconds, format: XinDongDateFormat.formatYMD);
  }

  // 登录时间显示
  // 大于7天 - "近期活跃"
  // 大于等于3天 - "近日活跃"
  // 2天 - 前天；1天 - 昨天
  // 大于1小时 - 1小时前（不分几小时）
  // 大于5分钟 - n分钟前
  // 5分钟以内 - 刚刚
  //
  // milliseconds 毫秒
  //
  // dateTime1.difference(dateTime2).inDays，dateTime1-dateTime2
  static String loginTime(int? milliseconds) {
    if (milliseconds == null) {
      return "近期活跃";
    }
    DateTime nowDate = DateTime.now();
    DateTime timeDate = DateTime.fromMillisecondsSinceEpoch(milliseconds);
    // 比较相差的天数（真实时分秒对比）
    int inDays = nowDate.difference(timeDate).inDays;
    if (inDays > 7) {
      return "近期活跃";
    }
    if (inDays >= 3) {
      return "近日活跃";
    }
    if (inDays == 2) {
      return "前天";
    }
    if (inDays == 1) {
      return "昨天";
    }
    // 比较相差的秒数
    int inSeconds = ((nowDate.millisecondsSinceEpoch - milliseconds) / 1000).round();

    if (inSeconds >= 60 * 60) {
      return "1小时前";
    }
    if (inSeconds > 5 * 60) {
      return "${(inSeconds / 60).round()}分钟前";
    }
    return "刚刚";
  }

  static bool calling(int time) {
    DateTime nowDate = DateTime.now();
    DateTime timeDate = DateTime.fromMillisecondsSinceEpoch(time);
    int inSeconds = nowDate.difference(timeDate).inSeconds;
    if (inSeconds > 60) {
      return false;
    }
    return true;
  }
}
